const app = getApp()
const api = require('../../utils/api')

Page({
  /**
   * 页面的初始数据
   */
  data: {
    orderNo: '',
    orderItems: [],
    rating: 0,
    ratingTexts: ['非常差', '差', '一般', '好', '非常好'],
    content: '',
    images: [],
    tempFilePaths: [], // 临时文件路径
    isAnonymous: false,
    canSubmit: false,
    userInfo: null,
    isSubmitting: false
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('评价页面参数:', options)
    
    if (options.orderNo) {
      this.setData({
        orderNo: options.orderNo
      })
      this.fetchOrderDetail(options.orderNo)
    } else {
      wx.showToast({
        title: '缺少订单信息',
        icon: 'none'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
    }
    
    // 设置默认值
    this.setData({
      rating: 5,
      ratingTexts: ['非常差', '差', '一般', '好', '非常好'],
      userInfo: wx.getStorageSync('userInfo') || null
    })
  },

  /**
   * 获取订单详情
   */
  async fetchOrderDetail(orderNo) {
    wx.showLoading({ title: '加载中...' })
    try {
      const res = await api.getCustomerOrderDetail(orderNo)
      
      console.log('订单详情数据结构:', JSON.stringify(res.data));
      
      if (res.success && res.data) {
        this.setData({
          orderItems: res.data.orderItems || []
        })
        
        // 查看orderItems的结构
        console.log('orderItems结构:', JSON.stringify(this.data.orderItems));
        
        // 检查orderItems的每一项是否包含productId
        if (this.data.orderItems && this.data.orderItems.length > 0) {
          const firstItem = this.data.orderItems[0];
          console.log('第一个订单项:', JSON.stringify(firstItem));
          console.log('商品ID:', firstItem.productId);
        }
      } else {
        wx.showToast({
          title: '获取订单信息失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('获取订单详情失败:', error)
      wx.showToast({
        title: '获取订单信息失败',
        icon: 'none'
      })
    } finally {
      wx.hideLoading()
    }
  },

  /**
   * 选择评分
   */
  selectRating(e) {
    const rating = e.currentTarget.dataset.rating
    this.setData({
      rating
    })
    this.checkCanSubmit()
  },

  /**
   * 评价内容输入
   */
  onContentInput(e) {
    this.setData({
      content: e.detail.value
    })
    this.checkCanSubmit()
  },

  /**
   * 选择图片
   */
  chooseImage() {
    const that = this
    if (that.data.images.length >= 6) {
      wx.showToast({
        title: '最多上传6张图片',
        icon: 'none'
      })
      return
    }

    wx.chooseMedia({
      count: 6 - that.data.images.length,
      mediaType: ['image'],
      sourceType: ['album', 'camera'],
      camera: 'back',
      success(res) {
        const tempFiles = res.tempFiles
        const tempFilePaths = tempFiles.map(file => file.tempFilePath)
        
        // 合并临时文件路径
        const newTempFilePaths = [...that.data.tempFilePaths, ...tempFilePaths]
        const newImages = [...that.data.images, ...tempFilePaths]
        
        that.setData({
          images: newImages,
          tempFilePaths: newTempFilePaths
        })
        that.checkCanSubmit()
      }
    })
  },

  /**
   * 删除图片
   */
  deleteImage(e) {
    const index = e.currentTarget.dataset.index
    const { images, tempFilePaths } = this.data
    
    // 从图片数组中删除相应索引的图片
    images.splice(index, 1)
    tempFilePaths.splice(index, 1)
    
    this.setData({
      images,
      tempFilePaths
    })
  },

  /**
   * 预览图片
   */
  previewImage(e) {
    const url = e.currentTarget.dataset.url
    wx.previewImage({
      current: url,
      urls: this.data.images
    })
  },

  /**
   * 切换匿名评价
   */
  toggleAnonymous(e) {
    this.setData({
      isAnonymous: e.detail.value
    })
  },

  /**
   * 检查是否可以提交
   */
  checkCanSubmit() {
    const { rating, content } = this.data
    const canSubmit = rating > 0 && content.trim().length > 0
    this.setData({ canSubmit })
  },

  /**
   * 上传图片
   */
  async uploadImages() {
    const { tempFilePaths } = this.data
    if (tempFilePaths.length === 0) {
      return []
    }

    console.log('开始上传图片，共', tempFilePaths.length, '张');
    
    try {
      const uploadTasks = tempFilePaths.map(tempFilePath => {
        return new Promise(async (resolve, reject) => {
          try {
            // 使用统一的图片上传API
            const uploadResult = await api.uploadImage(tempFilePath, false);
            console.log(`图片上传结果:`, uploadResult);
            
            if (uploadResult && uploadResult.success && uploadResult.data && uploadResult.data.url) {
              resolve(uploadResult.data.url);
            } else {
              console.error(`图片上传失败:`, uploadResult);
              reject(new Error(uploadResult.message || '上传图片失败'));
            }
          } catch (error) {
            console.error(`图片上传错误:`, error);
            reject(error);
          }
        });
      });

      try {
        return await Promise.all(uploadTasks);
      } catch (error) {
        console.error('部分图片上传失败:', error);
        // 如果图片上传失败，但用户已填写评价内容和评分，我们仍然允许提交评价
        return new Promise((resolve, reject) => {
          wx.showModal({
            title: '提示',
            content: '部分图片上传失败，是否继续提交评价？',
            success: (res) => {
              if (res.confirm) {
                // 过滤掉上传失败的图片，只保留成功的
                const successUrls = uploadTasks
                  .filter(task => task.status === 'fulfilled')
                  .map(task => task.value);
                resolve(successUrls);
              } else {
                reject(new Error('用户取消评价')); // 用户选择取消，终止提交
              }
            }
          });
        });
      }
    } catch (outerError) {
      console.error('上传过程异常:', outerError);
      // 如果图片上传失败，但用户已填写评价内容和评分，我们提供选择
      return new Promise((resolve, reject) => {
        wx.showModal({
          title: '提示',
          content: '图片上传失败，是否继续提交纯文字评价？',
          success: (res) => {
            if (res.confirm) {
              resolve([]); // 返回空数组，表示没有图片
            } else {
              reject(new Error('用户取消评价')); // 用户选择取消，终止提交
            }
          }
        });
      });
    }
  },

  /**
   * 提交评价
   */
  async submitReview() {
    if (!this.data.canSubmit || this.data.isSubmitting) {
      return
    }

    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    // 获取产品ID
    let productId = 0;
    if (this.data.orderItems && this.data.orderItems.length > 0) {
      const firstItem = this.data.orderItems[0];
      console.log('准备提取商品ID:', JSON.stringify(firstItem));
      
      // 根据实际数据结构获取productId
      if (firstItem.product && firstItem.product.id) {
        productId = firstItem.product.id;
        console.log('从product.id获取商品ID:', productId);
      } else if (firstItem.productId) {
        productId = firstItem.productId;
        console.log('从productId获取商品ID:', productId);
      } else if (firstItem.id) {
        productId = firstItem.id;
        console.log('从id获取商品ID:', productId);
      }
    }
    
    console.log('提交评价，商品ID:', productId, '订单号:', this.data.orderNo);

    if (!productId) {
      wx.showToast({
        title: '无法获取商品信息',
        icon: 'none'
      });
      return;
    }

    this.setData({ isSubmitting: true })
    
    // 确保在函数开始时没有遗留的loading状态
    try {
      wx.hideLoading()
    } catch (e) {
      // 忽略可能的错误
    }
    
    wx.showLoading({ title: '提交中...' })

    let imageUrls = [];
    try {
      // 只有当用户选择了图片时才尝试上传
      if (this.data.tempFilePaths.length > 0) {
        try {
          // 先上传图片
          imageUrls = await this.uploadImages();
          console.log('上传图片完成，获取到的URL:', imageUrls);
        } catch (uploadError) {
          console.error('图片上传错误，继续提交纯文本评价', uploadError);
          // 上传失败但用户选择了继续，使用空数组
          imageUrls = [];
          
          // 显示一个简短的提示
          wx.showToast({
            title: '图片上传失败，继续提交评价',
            icon: 'none',
            duration: 1500
          });
        }
      }
      
      // 构建评价数据
      const reviewData = {
        orderNo: this.data.orderNo,
        productId: productId,
        rating: this.data.rating,
        content: this.data.content,
        isAnonymous: this.data.isAnonymous,
        imageUrls: imageUrls, // 确保图片URLs正确设置
      };
      
      console.log('评价数据:', reviewData);
      
      // 发送请求
      const res = await api.submitReview(reviewData);
      
      if (res && res.success) {
        wx.hideLoading();
        wx.showToast({
          title: '评价成功',
          icon: 'success',
          duration: 2000
        });
        
        // 延迟返回，让用户看到成功提示
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      } else {
        wx.hideLoading();
        wx.showToast({
          title: res.message || '评价失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('提交评价失败:', error)
      // 确保关闭loading后再显示toast
      wx.hideLoading()
      wx.showToast({
        title: error.message || '评价失败，请稍后重试',
        icon: 'none'
      })
    } finally {
      this.setData({ isSubmitting: false })
      // 确保最后一定会关闭loading，防止loading悬挂
      setTimeout(() => {
        wx.hideLoading()
      }, 100) 
    }
  }
}) 